// 使用统一配置入口模式导入所有模块
const { ProjectBiz, PlmBiz } = require('../../../config/biz_config');
const { ProjectModel } = require('../../../config/models_config');
const { 
	pageHelper, 
	cloudHelper, 
	timeHelper, 
	dataHelper, 
	validateHelper, 
	fileHelper, 
	errorHelper, 
	cacheHelper, 
	formHelper, 
	helper,
	dateHelper,
	statusHelper 
} = require('../../../config/project_helpers_config');

// 从统一配置入口导入MobX相关模块
const { createStoreBindings, plmProjectStore, userStore, researchStateMachineStore } = require('../../../config/store_config');

// 使用统一配置入口模式导入模块
const { ProjectVersionBiz, ProjectBranchBiz } = require('../../../config/biz_config');
const { ProjectFeedbackBiz } = require('../../../config/biz_config');
const { PassportBiz, userBiz } = require('../../../config/passport_biz_config');
const setting = require('../../../config/projects');
const { ProjectDataBiz } = require('../../../config/services_config');

// 导入全局应用实例
const app = getApp();

// 缓存控制常量
const CACHE_EXPIRE_TIME = 30 * 60 * 1000; // 缓存30分钟
const MAX_CACHE_SIZE = 10 * 1024 * 1024; // 最大缓存10MB
const PAGE_SIZE = 20;

const branchService = require('../../../services/branch_service');
const projectStore = require('../../../store/plm_project_store');
const stateService = require('../../../services/project_state_service');

const { logEvent } = require('../../../../helpers/log_helper.js');
const { getNetworkStatus, listenNetworkStatus } = require('../../../../helpers/network_helper.js');

/**
 * 研发管理页面
 * 此页面使用模块化架构，将复杂逻辑委托给各管理器模块处理
 */
Page({
	options: {
		addGlobalClass: true // 添加全局样式支持
	},
	/**
	 * 数据
	 */
	data: {
		id: '',
		project: null,
		mode: 'detail', // detail, edit
		isLoad: false,
		error: false,
		errorMessage: '',
		options: null,
		isAdmin: false,
		isOwner: false,
		parentProject: null,
		showParentInfo: false,
		
		// 分支相关
		branchProjects: [],
		branchOptions: [{ id: '', name: '主分支' }], // 默认显示主分支选项
		currentBranchIndex: 0,
		currentBranchId: '',
		
		// 资源文件夹结构
		resourceFolders: [
			{ id: 'package', name: '包装指引', files: [] },
			{ id: 'process', name: '加工指引', files: [] },
			{ id: 'material', name: '物料变更通知', files: [] },
			{ id: 'bom', name: 'BOM', files: [] },
			{ id: 'report', name: '认证报告', files: [] },
			{ id: 'test_report', name: '测试报告', files: [] },
			{ id: 'test_guide', name: '测试指引', files: [] },
			{ id: 'spec', name: '产品规格书', files: [] },
			{ id: 'code', name: '代码', files: [] },
			{ id: 'firmware', name: '烧录文件', files: [] },
			{ id: 'structure', name: '结构', files: [] },
			{ id: 'customer', name: '客户文件', files: [] },
			{ id: 'component', name: '元器件 规格书', files: [] },
			{ id: 'schematic', name: '原理图', files: [] },
			{ id: 'pcb', name: 'PCB', files: [] },
			{ id: 'manual', name: '作业指导书', files: [], active: true }
		],
		selectedFolderId: 'manual', // 默认选中的文件夹
		currentFolderName: '作业指导书', // 当前选中文件夹的名称
		
		// 标签页相关
		currentTab: 0, // 默认显示总览标签页
		
		flowHistory: [],
		
		// 状态选择
		nextStateOptions: [], // 包含每个状态所需的资料信息
		selectedState: -1,
		
		// 活跃状态选择
		nextActiveStateOptions: [],
		selectedActiveState: -1,
		
		// 流转备注
		flowNote: '',
		
		// 分支选择
		branchOptions: [],
		currentBranchIndex: 0,
		
		// 进度条详情显示控制
		showProgressDesc: false,
		
		// 路径图相关
		isFullScreen: false,
		showPathInfoModal: false,
		pathScale: 1,
		
		// 资源上传权限
		canUploadResource: true,
		
		// 添加资源提交相关数据
		selectedStateResourceTypes: [],
		resourceUploads: [],
		
		// 资料上传相关
		uploadedDocs: [], // 已上传的资料列表
		
		// 状态流转相关
		selectedEvent: -1,
		availableEvents: [], // 当前状态可用的事件列表
		targetMainStatusName: '', // 目标主状态名称
		targetSubStatusName: '', // 目标子状态名称
		requiredDocs: [], // 所需资料列表
		canSubmitFlow: false,

		// 调试模式相关
		isDebugMode: false,
		simulatedRole: null,
		currentRoleName: '',
		isCreateMode: false,
		
		// 进度
		progress: 10,
	
		// 新增的资源筛选相关
		resourceFilter: 'all',
		isLoading: true,
		showAction: false,
		projectCode: '',
		isProjectMember: false,
		currentTab: 0,
		userRole: 'visitor',
		hasFlowPermission: false,
		
		// 新增的branch相关
		loading: true,
		currentProject: null,
		branchId: null,
		
		// 新增的状态机相关
		stateHistory: [],
		availableTransitions: [],
		
		// 新增的标签页相关
		hasFlowPermission: false
	},

	/**
	 * 导入依赖
	 */
	// 依赖库和服务已在顶部导入
	ProjectDataBiz: require('../../../config/services_config').ProjectDataBiz,

	/**
	 * 生命周期函数--监听页面加载
	 */
	onLoad: async function (options) {
		// 网络检测
		const net = await getNetworkStatus();
		if (!net.isConnected) {
			wx.showToast({ title: '当前无网络，请检查连接', icon: 'none' });
		} else if (net.networkType === '2g') {
			wx.showToast({ title: '当前为2G弱网，体验可能受影响', icon: 'none' });
		}
		listenNetworkStatus((res) => {
			if (!res.isConnected) wx.showToast({ title: '网络已断开', icon: 'none' });
			else if (res.networkType === '2g') wx.showToast({ title: '当前为2G弱网', icon: 'none' });
		});
		logEvent('page_load', { page: 'plm_project_detail' });
		try {
			// 保存参数
			let projectId = options.id || '';
			
			if (!projectId) {
				this.setData({
					isLoad: true,
					error: true,
					errorMessage: '未找到项目ID'
				});
				return;
			}
			
			// 如果是mock003项目，清除缓存
			if (projectId === 'mock003') {
				console.log('[项目详情] 检测到mock003项目，清除缓存');
				try {
					// 尝试获取缓存服务并清除缓存
					const storeWrapper = require('../../../store/plm_project_store_wrapper.js');
					if (storeWrapper && storeWrapper._getCacheService && storeWrapper._getCacheService.removeProjectDetail) {
						storeWrapper._getCacheService.removeProjectDetail('mock003');
						console.log('[项目详情] 成功清除mock003项目缓存');
					} else {
						console.warn('[项目详情] 清除缓存失败');
						
						// 使用pageHelper尝试清除缓存
						if (this.data.pageHelper && this.data.pageHelper.remove) {
							this.data.pageHelper.remove('plm_project_detail_mock003');
							console.log('[项目详情] 使用pageHelper成功清除mock003项目缓存');
						}
					}
				} catch (cacheError) {
					console.warn('[项目详情] 清除缓存失败:', cacheError);
				}
			}
			
			this.setData({
				options,
				id: projectId,
				isLoad: false
			});
		
			// 绑定项目Store
			this.projectStoreBindings = createStoreBindings(this, {
				store: plmProjectStore,
				fields: ['loading', 'error', 'currentProject'],
				actions: ['getProjectDetail', 'clearProject']
			});
			
			// 如果存在项目基础Store，也尝试绑定
			try {
				const { projectStore } = require('../../../store/project_store');
				if (projectStore) {
					this.baseProjectStoreBindings = createStoreBindings(this, {
						store: projectStore,
						actions: ['resetCurrentProject']
					});
					console.log('[项目详情] 成功绑定基础项目Store的resetCurrentProject方法');
				}
			} catch (e) {
				console.log('[项目详情] 基础项目Store不可用，跳过绑定resetCurrentProject');
			}
			
			// 绑定状态机Store
			if (researchStateMachineStore) {
				this.stateMachineBindings = createStoreBindings(this, {
					store: researchStateMachineStore,
					fields: [
						'currentRole',
						'availableEvents',
						'requiredDocs'
					]
				});
			}
			
			// 绑定用户Store
			this.userStoreBindings = createStoreBindings(this, {
				store: userStore,
				fields: ['user', 'isLogin', 'isAdmin'],
				actions: ['getUserInfo']
			});
		
			// 初始化页面数据
			await this._init();
			
			// 初始化项目分支数据
			await this._initBranches();
		} catch (err) {
			console.error('[项目详情] 页面加载错误:', err);
			this.setData({
				isLoad: true,
				error: true,
				errorMessage: err.message || '加载失败'
			});
		}
	},
	
	/**
	 * 页面初始化
	 */
	async _init() {
		try {
			// 加载用户信息
			if (this.data.isLogin) {
				await this.getUserInfo();
			}
			
			// 加载项目详情
			await this._loadProjectData(this.data.id);
			
			// 完成初始化
			this.setData({
				isInit: true
			});
		} catch (err) {
			console.error('[项目详情] 初始化失败:', err);
			this.setData({
				error: true,
				errorMessage: err.message || '初始化失败'
			});
		}
	},
	
	/**
	 * 加载项目详情
	 */
	async _loadProjectData(projectId) {
		try {
			if (!projectId) {
				throw new Error('项目ID不能为空');
			}
			
			// 显示加载中
			wx.showLoading({
				title: '加载项目中...',
				mask: true
			});
			
			console.log('[项目详情] 开始加载项目数据:', projectId);
			
			// 尝试从缓存获取数据
			let projectData = null;
			try {
				const cachedData = await this._getCachedProjectData(projectId);
				if (cachedData) {
					console.log('[项目详情] 使用缓存数据');
					projectData = cachedData;
				}
			} catch (cacheError) {
				console.warn('[项目详情] 缓存获取失败，将直接请求API:', cacheError);
			}
			
			// 如果没有缓存数据，尝试使用Store的getProjectDetail方法
			if (!projectData) {
				try {
					if (this.getProjectDetail && typeof this.getProjectDetail === 'function') {
						console.log('[项目详情] 使用Store的getProjectDetail方法获取数据');
						await this.getProjectDetail(projectId);
						// 从Store获取数据
						projectData = this.data.currentProject;
					}
				} catch (storeError) {
					console.warn('[项目详情] Store方法获取失败，将直接请求API:', storeError);
				}
			}
			
			// 如果Store方法不可用或出错，直接调用API获取项目数据
			if (!projectData) {
				console.log('[项目详情] 直接调用API获取项目数据');
				const result = await cloudHelper.callCloudData('plm/project_detail', {
					id: projectId
				});
				
				if (result && result.data) {
					projectData = result.data;
				} else {
					throw new Error('项目数据获取失败');
				}
			}
			
			// 更新项目数据
			this.setData({
				project: projectData,
				currentProject: projectData,
				isLoad: true
			});
			
			// 并行加载其他数据
			await Promise.all([
				this._getBranchProjects(),
				this._getResourceVersionList(),
				this._getProjectFlowHistory()
			]).catch(err => {
				console.warn('[项目详情] 部分数据加载失败:', err);
				// 忽略次要数据加载失败
			});
			
			// 格式化项目数据
			this._updateComputedData();
			
			// 初始化项目权限
			this._initProjectPermissions();
			
			// 更新标签内容
			this._updateTabContent();
			
			// 缓存项目数据
			try {
				await this._cacheProjectData(projectId, projectData);
			} catch (cacheError) {
				console.warn('[项目详情] 缓存项目数据失败:', cacheError);
			}
			
			// 设置加载完成标志
			this.setData({
				isLoad: true,
				loading: false
			});
			
			console.log('[项目详情] 项目数据加载完成');
			
			// 隐藏加载提示
			wx.hideLoading();
			
			return projectData;
		} catch (err) {
			console.error('[项目详情] 加载项目数据失败:', err);
			
			// 隐藏加载提示
			wx.hideLoading();
			
			// 显示错误提示
			wx.showToast({
				title: '加载失败: ' + (err.message || '未知错误'),
				icon: 'none'
			});
			
			// 重置加载状态
			this.setData({
				isLoad: true,
				loading: false,
				error: true,
				errorMessage: err.message || '加载失败'
			});
			
			return null;
		}
	},
	
	/**
	 * 获取缓存的项目数据
	 */
	async _getCachedProjectData(projectId) {
		try {
			if (!projectId) return null;
			
			// 尝试直接从页面数据中获取
			if (this.data.currentProject && this.data.currentProject._id === projectId) {
				return this.data.currentProject;
			}
			
			// 尝试从Store缓存服务获取
			try {
				const storeWrapper = require('../../../store/plm_project_store_wrapper.js');
				if (storeWrapper && storeWrapper._getCacheService && 
					typeof storeWrapper._getCacheService.getProjectDetail === 'function') {
					const cachedData = await storeWrapper._getCacheService.getProjectDetail(projectId);
					if (cachedData) return cachedData;
				}
			} catch (storeError) {
				console.warn('[项目详情] Store缓存服务不可用:', storeError);
			}
			
			// 尝试从页面缓存中获取
			try {
				const cacheKey = `plm_project_detail_${projectId}`;
				const cachedData = wx.getStorageSync(cacheKey);
				if (cachedData) {
					// 检查缓存是否过期（10分钟）
					const now = Date.now();
					if (cachedData.timestamp && (now - cachedData.timestamp) < 10 * 60 * 1000) {
						return cachedData.data;
					}
				}
			} catch (wxError) {
				console.warn('[项目详情] 微信存储API不可用:', wxError);
			}
			
			return null;
		} catch (err) {
			console.warn('[项目详情] 获取缓存数据失败:', err);
			return null;
		}
	},
	
	/**
	 * 缓存项目数据
	 */
	async _cacheProjectData(projectId, projectData) {
		try {
			if (!projectId || !projectData) return;
			
			// 尝试使用Store缓存服务
			try {
				const storeWrapper = require('../../../store/plm_project_store_wrapper.js');
				if (storeWrapper && storeWrapper._getCacheService && 
					typeof storeWrapper._getCacheService.setProjectDetail === 'function') {
					await storeWrapper._getCacheService.setProjectDetail(projectId, projectData);
					return;
				}
			} catch (storeError) {
				console.warn('[项目详情] Store缓存服务不可用:', storeError);
			}
			
			// 备用方案：使用微信存储API
			try {
				const cacheKey = `plm_project_detail_${projectId}`;
				const cacheData = {
					data: projectData,
					timestamp: Date.now()
				};
				wx.setStorageSync(cacheKey, cacheData);
			} catch (wxError) {
				console.warn('[项目详情] 微信存储API不可用:', wxError);
			}
		} catch (err) {
			console.warn('[项目详情] 缓存数据失败:', err);
		}
	},
	
	/**
	 * 检查用户权限
	 */
	_checkPermissions() {
		const project = this.data.project;
		const user = this.data.user;
		
		if (!project || !user) return;
		
		// 检查是否管理员
		const isAdmin = this.data.isAdmin;
		
		// 检查是否项目创建者
		const isOwner = project.createBy === user._id;
		
		// 检查用户权限并更新界面
		this.setData({
			isAdmin,
			isOwner,
			canUploadResource: isAdmin || isOwner
		});
		
		// 检查流转权限
		this._checkFlowPermission(project, user);
	},
	
	/**
	 * 设置项目状态文本
	 */
	_setProjectStatusText(project) {
		if (!project) return;
		
		// 使用statusHelper获取状态文本
		let statusText = statusHelper.getStatusText(project.level1, project.level2);
		
		// 如果statusHelper未能提供状态文本，使用项目自身的状态描述或默认值
		if (!statusText || statusText.includes('未知状态')) {
			statusText = project.statusDesc || project.statusText || '未知状态';
		}
		
		// 更新项目状态文本
		project.statusText = statusText;
	},
	
	/**
	 * 计算项目进度
	 */
	_calculateProgress(project) {
		if (!project) return;
		
		// 使用statusHelper获取项目完成度百分比
		let progress = statusHelper.getCompletionPercentage(project);
		
		// 如果完成度未能正确计算，使用基础状态映射
		if (progress === 0 && project.status !== 0 && project.status !== undefined) {
			// 基础进度映射（作为备选方案）
			const baseProgressMap = {
				0: 0,   // 草稿
				1: 10,  // 待立项
				2: 20,  // 已立项
				3: 40,  // 设计中
				4: 60,  // 开发中
				5: 80,  // 测试中
				6: 100, // 已完成
				99: 0   // 已取消
			};
			
			progress = baseProgressMap[project.status] || 0;
		}
		
		this.setData({
			progress
		});
	},

	/** 
	 * 获取项目流转历史
	 */
	async _getProjectFlowHistory() {
		try {
			const result = await cloudHelper.callCloudData('project/flow_history', {
				id: this.data.id
			});
			
			if (result && result.list) {
				const flowHistory = result.list.map(item => {
					// 使用dateHelper格式化日期时间
					if (item.createTime) {
						const formattedTime = dateHelper.timestampToDate(item.createTime, 'YYYY-MM-DD HH:mm');
						item.createTime = formattedTime || timeHelper.formatDateTime(item.createTime);
					}
					return item;
				});
				
				this.setData({
					flowHistory
				});
			}
		} catch (err) {
			console.error('[项目详情] 获取流转历史失败:', err);
		}
	},
	
	/**
	 * 获取项目分支列表
	 */
	async _getBranchProjects() {
		try {
			const result = await cloudHelper.callCloudData('project/branch_list', {
				id: this.data.id
			});
			
			if (result && result.list) {
				this.setData({
					branchProjects: result.list
				});
				
				// 初始化分支选项
				this._initBranchOptions(result.list, this.data.project);
			}
		} catch (err) {
			console.error('[项目详情] 获取分支列表失败:', err);
		}
	},
	
	/**
	 * 获取项目资源版本列表
	 */
	async _getResourceVersionList() {
		try {
			const result = await cloudHelper.callCloudData('project/resource_list', {
				id: this.data.id
			});
			
			if (result && result.list) {
				// 处理资源数据
				this._processResourceData(result.list);
			}
		} catch (err) {
			console.error('[项目详情] 获取资源列表失败:', err);
		}
	},

	/**
	 * 处理资源数据
	 */
	_processResourceData(resources) {
		if (!resources || !resources.length) return;
		
		// 按文件夹分组资源
		const resourceFolders = [...this.data.resourceFolders];
		
		// 清空所有文件夹的文件列表
		resourceFolders.forEach(folder => {
			folder.files = [];
		});
		
		// 将资源分配到对应文件夹
		resources.forEach(resource => {
			const folder = resourceFolders.find(f => f.id === resource.type);
			if (folder) {
				// 使用dateHelper格式化资源日期
				resource.createTime = dateHelper.timestampToDate(resource.createTime, 'YYYY-MM-DD HH:mm') || 
					timeHelper.formatDateTime(resource.createTime);
				resource.updateTime = dateHelper.timestampToDate(resource.updateTime, 'YYYY-MM-DD HH:mm') || 
					timeHelper.formatDateTime(resource.updateTime);
				
				// 添加到文件夹
				folder.files.push(resource);
			}
		});
		
		// 更新文件夹数据
		this.setData({
			resourceFolders
		});
		
		// 显示选中文件夹的资源
		this._showSelectedFolderResources();
	},

	/**
	 * 显示选中文件夹的资源
	 */
	_showSelectedFolderResources() {
		const selectedFolder = this.data.resourceFolders.find(
			folder => folder.id === this.data.selectedFolderId
		);
		
		if (selectedFolder) {
			this.setData({
				currentFolderName: selectedFolder.name
			});
			
			// 应用资源筛选
			this._applyResourceFilter();
		}
	},

	/**
	 * 应用资源筛选
	 */
	_applyResourceFilter() {
		const { selectedFolderId, resourceFilter } = this.data;
		
		const selectedFolder = this.data.resourceFolders.find(
			folder => folder.id === selectedFolderId
		);
		
		if (!selectedFolder) return;
		
		// 筛选文件
		let filteredFiles = [...selectedFolder.files];
		
		// 根据筛选条件过滤
		if (resourceFilter !== 'all') {
			filteredFiles = filteredFiles.filter(file => {
				if (resourceFilter === 'latest') {
					// 只显示最新版本
					return file.isLatest;
				} else if (resourceFilter === 'archived') {
					// 只显示归档版本
					return file.isArchived;
				}
				return true;
			});
		}
		
		this.setData({
			filteredResources: filteredFiles
		});
	},
	
	/**
	 * 检查流转权限
	 */
	_checkFlowPermission(project, userInfo) {
		// 触发状态机计算权限
		if (researchStateMachineStore) {
			researchStateMachineStore.computeAvailableEvents(project, userInfo);
			
			this.setData({
				availableEvents: this.data.availableEvents || []
			});
			
			// 检查是否可以提交流转
			this._checkCanSubmitFlow();
		}
	},
	
	/**
	 * 检查是否可以提交流转
	 */
	_checkCanSubmitFlow() {
		// 检查是否有可用事件
		const canSubmitFlow = this.data.availableEvents && this.data.availableEvents.length > 0;
		
		this.setData({
			canSubmitFlow
		});
	},
	
	/**
	 * 初始化分支选项
	 */
	_initBranchOptions(branchProjects, project) {
		if (!branchProjects || !project) return;
		
		// 构建分支选项
		const branchOptions = [{ id: '', name: '主分支' }];
		
		branchProjects.forEach(branch => {
			branchOptions.push(this.formatBranchItem(branch));
		});
		
		this.setData({
			branchOptions
		});
	},

	// 格式化分支数据
	formatBranchItem(branch) {
		return {
			id: branch._id,
			name: branch.branchName || branch.projectType
		};
	},

	/**
	 * 加载反馈列表
	 */
	async loadFeedbackList() {
		try {
			const result = await cloudHelper.callCloudData('project/feedback_list', {
				projectId: this.data.id
			});
		
			if (result && result.list) {
				// 格式化日期时间
				const feedbackList = result.list.map(item => {
					item.createTime = timeHelper.formatDateTime(item.createTime);
					return item;
				});
				
				this.setData({
					feedbackList
				});
			}
		} catch (err) {
			console.error('[项目详情] 加载反馈列表失败:', err);
		}
	},

	/**
	 * 监听MobX数据变化
	 */
	onStoreChange: function() {
		// 处理项目数据变化
		if (this.data.currentProject) {
			this.setData({
				project: this.data.currentProject
			});
		}
		
		// 处理状态机数据变化
		if (this.data.availableEvents) {
			this._checkCanSubmitFlow();
		}
		
		// 处理错误信息
		if (this.data.error) {
			pageHelper.showErrToast(this.data.error);
		}
	},

	/**
	 * 文件夹点击事件
	 */
	onFolderTap(e) {
		const folderId = e.currentTarget.dataset.id;
		if (folderId === this.data.selectedFolderId) return;
		
		// 更新选中文件夹
		this.setData({
			selectedFolderId: folderId
		});
		
		// 显示选中文件夹的资源
		this._showSelectedFolderResources();
	},

	/**
	 * 资源筛选变更
	 */
	onResourceFilterChange(e) {
		const filter = e.currentTarget.dataset.filter;
		
		this.setData({
			resourceFilter: filter
		});
		
		// 应用筛选
		this._applyResourceFilter();
	},

	/**
	 * 标签切换
	 */
	onTabChange(e) {
		const { tab } = e.currentTarget.dataset;
		const index = parseInt(tab);
		
		this.setData({
			currentTab: index
		});
		
		// 更新标签页内容
		this._updateTabContent();
	},

	/**
	 * 更新标签页内容
	 */
	_updateTabContent() {
		const { currentTab } = this.data;
		
		// 根据当前标签加载对应数据
		switch(currentTab) {
			case 0: // 图谱标签
				// 加载图谱数据
				this._loadGraphData();
				break;
				
			case 1: // 总览标签
				// 确保项目数据已格式化
				this._updateComputedData();
				break;
				
			case 2: // 流转标签
				// 加载流转历史
				this._loadFlowHistoryData();
				break;
				
			case 3: // 任务标签
				// 加载任务数据
				this._loadTaskData();
				break;
				
			case 4: // 资料标签
				// 显示资料数据
				this._showSelectedFolderResources();
				break;
				
			case 5: // 反馈标签
				// 加载反馈数据
				this.loadFeedbackList();
				break;
		}
	},

	/**
	 * 加载图谱数据
	 */
	_loadGraphData() {
		// 图谱数据加载逻辑（不受分支切换影响）
		console.log('[项目详情] 加载图谱数据');
		
		// TODO: 实现图谱数据加载逻辑
		// 这里可以调用图谱服务或组件方法
	},
	
	/**
	 * 加载流转历史数据
	 */
	_loadFlowHistoryData() {
		// 流转历史加载逻辑
		console.log('[项目详情] 加载流转历史数据');
		
		// 获取流转历史
		this._getProjectFlowHistory();
		
		// 检查流转权限
		this._checkPermissions();
	},
	
	/**
	 * 加载任务数据
	 */
	_loadTaskData() {
		// 任务数据加载逻辑
		console.log('[项目详情] 加载任务数据');
		
		// TODO: 实现任务数据加载逻辑
		// 可以添加任务加载相关方法
	},

	/**
	 * 状态变更事件
	 */
	onEventChange(e) {
		const eventId = parseInt(e.detail.value);
		
		// 更新选中的事件
		this.setData({
			selectedEvent: eventId
		});
		
		// 获取目标状态信息
		if (researchStateMachineStore) {
			const targetState = researchStateMachineStore.getTargetStateByEvent(eventId);
			
			if (targetState) {
				this.setData({
					targetMainStatusName: targetState.name,
					targetSubStatusName: targetState.subName,
					requiredDocs: this.data.requiredDocs || []
				});
			}
		}
		
		// 检查可以提交流转
		this._checkCanSubmitFlow();
	},
	
	/**
	 * 流转备注输入
	 */
	onFlowNoteInput(e) {
		this.setData({
			flowNote: e.detail.value
		});
	},
	
	/**
	 * 提交流转
	 */
	async onSubmitFlow() {
		try {
			const { selectedEvent, flowNote, id } = this.data;
			
			// 验证选择
			if (selectedEvent < 0) {
				return pageHelper.showErrToast('请选择要执行的操作');
			}
			
			// 获取目标状态
			const targetState = researchStateMachineStore.getTargetStateByEvent(selectedEvent);
			if (!targetState) {
				return pageHelper.showErrToast('无效的操作');
			}
			
			// 确认操作
			const confirm = await pageHelper.showConfirm(`确定要将项目状态变更为"${targetState.name}"吗？`);
			if (!confirm) return;
			
			// 显示加载中
			wx.showLoading({
				title: '处理中...',
				mask: true
			});
			
			// 提交流转
			const result = await cloudHelper.callCloudSumbit('project/flow', {
				id,
				event: selectedEvent,
				note: flowNote
			});
			
			// 隐藏加载中
			wx.hideLoading();
			
			if (result) {
				// 显示成功提示
				pageHelper.showSuccessToast('状态更新成功');
				
				// 重新加载项目详情
				await this.getProjectDetail(id);
				
				// 重新加载流转历史
				await this._getProjectFlowHistory();
				
				// 重置表单
				this.setData({
					selectedEvent: -1,
					flowNote: ''
				});
			}
		} catch (err) {
			wx.hideLoading();
			console.error('[项目详情] 提交流转失败:', err);
			pageHelper.showErrToast(err.message || '操作失败');
		}
	},

	/**
	 * 编辑项目点击
	 */
	onEditTap() {
		const id = this.data.id;
		
		wx.navigateTo({
			url: `/projects/plm/pages/project/edit/project_edit?id=${id}`
		});
	},
	
	/**
	 * 添加资源点击
	 */
	onAddResourceTap() {
		const id = this.data.id;
		
		wx.navigateTo({
			url: `/projects/plm/pages/project/resource/resource_add?projectId=${id}`
		});
	},

	/**
	 * 创建分支点击
	 */
	onCreateBranchTap() {
		const id = this.data.id;
		
		wx.navigateTo({
			url: `/projects/plm/pages/project/branch/branch_add?projectId=${id}`
		});
	},

	/**
	 * 流转点击
	 */
	onFlowTap() {
		// 切换到流转标签
		this.setData({
			currentTab: 5
		});
		
		// 更新标签页内容
		this._updateTabContent();
	},

	/**
	 * 创建任务点击
	 */
	onCreateTaskTap() {
		const id = this.data.id;
		
		wx.navigateTo({
			url: `/projects/plm/pages/project/task/edit/task_edit?projectId=${id}`
		});
	},

	/**
	 * 任务列表点击
	 */
	onTaskListTap() {
		const id = this.data.id;
		
		wx.navigateTo({
			url: `/projects/plm/pages/project/task/list/task_list?projectId=${id}`
		});
	},

	/**
	 * 查看资料点击
	 */
	onViewDocTap(e) {
		const { url } = e.currentTarget.dataset;
		if (!url) return;
		
		// 使用云文件ID打开文件
		cloudHelper.openDoc({
			url,
			success: () => {
				console.log('打开文档成功');
			},
			fail: (err) => {
				console.error('打开文档失败', err);
				pageHelper.showModal('打开文件失败');
			}
		});
	},

	/**
	 * 下载资料点击
	 */
	onDownloadDocTap(e) {
		const { url } = e.currentTarget.dataset;
		if (!url) return;
		
		// 使用云文件ID下载文件
		cloudHelper.downloadFile({
			url,
			success: (res) => {
				pageHelper.showSuccessToast('文件已保存');
			},
			fail: (err) => {
				console.error('下载文件失败', err);
				pageHelper.showModal('下载文件失败');
			}
		});
	},

	/**
	 * 分支切换事件
	 */
	onBranchChange(e) {
		const { branch } = e.detail;
		console.log('分支已选择:', branch);
		
		// 如果选择的是当前分支，不做处理
		if (this.data.currentBranch && this.data.currentBranch._id === branch._id) {
			return;
		}
		
		this.switchBranch(branch._id);
	},

	/**
	 * 显示进度详情
	 */
	showProgressDetail() {
		this.setData({
			showProgressDesc: !this.data.showProgressDesc
		});
	},

	/**
	 * 返回列表
	 */
	onBackToList() {
		wx.navigateBack({
			delta: 1
		});
	},

	/**
	 * 添加反馈点击
	 */
	onAddFeedbackTap() {
		const id = this.data.id;
		
		wx.navigateTo({
			url: `/projects/plm/pages/project/feedback/feedback_add?projectId=${id}`
		});
	},
	
	/**
	 * 反馈项点击
	 */
	onFeedbackItemTap(e) {
		const { id } = e.currentTarget.dataset;
		if (!id) return;
		
		wx.navigateTo({
			url: `/projects/plm/pages/project/feedback/feedback_detail?id=${id}`
		});
	},
	
	/**
	 * 生命周期函数--监听页面卸载
	 */
	onUnload: function() {
		try {
			// 安全地清除项目数据
			try {
				// 首先尝试使用clearProject方法（我们绑定的）
				if (typeof this.clearProject === 'function') {
					console.log('[项目详情] 使用clearProject方法清除当前项目数据');
					this.clearProject();
				}
				
				// 如果基础项目Store的resetCurrentProject方法可用，也调用它
				if (this.baseProjectStoreBindings && typeof this.resetCurrentProject === 'function') {
					console.log('[项目详情] 使用基础项目Store的resetCurrentProject方法清除当前项目数据');
					this.resetCurrentProject();
				}
			} catch (resetError) {
				console.warn('[项目详情] 清除项目数据时遇到错误，忽略', resetError);
			}
			
			// 销毁所有MobX绑定
			// 销毁项目Store绑定
			if (this.projectStoreBindings) {
				try {
					this.projectStoreBindings.destroyStoreBindings();
					console.log('[项目详情] 项目Store绑定已清理');
				} catch (err) {
					console.error('[项目详情] 清理项目Store绑定失败', err);
				}
			}
			
			// 销毁基础项目Store绑定
			if (this.baseProjectStoreBindings) {
				try {
					this.baseProjectStoreBindings.destroyStoreBindings();
					console.log('[项目详情] 基础项目Store绑定已清理');
				} catch (err) {
					console.error('[项目详情] 清理基础项目Store绑定失败', err);
				}
			}
			
			// 销毁状态机Store绑定
			if (this.stateMachineBindings) {
				try {
					this.stateMachineBindings.destroyStoreBindings();
					console.log('[项目详情] 状态机Store绑定已清理');
				} catch (err) {
					console.error('[项目详情] 清理状态机Store绑定失败', err);
				}
			}
			
			// 销毁用户Store绑定
			if (this.userStoreBindings) {
				try {
					this.userStoreBindings.destroyStoreBindings();
					console.log('[项目详情] 用户Store绑定已清理');
				} catch (err) {
					console.error('[项目详情] 清理用户Store绑定失败', err);
				}
			}
		} catch (err) {
			console.error('[项目详情] 页面卸载清理失败', err);
		}
	},

	/**
	 * 处理项目状态更新事件
	 */
	async onProjectStateUpdated(e) {
		try {
			console.log('项目状态已更新', e.detail);
			
			// 显示加载中
			wx.showLoading({
				title: '更新中...',
				mask: true
			});
			
			// 更新项目数据
			const { project } = e.detail;
			if (project) {
				// 更新本地数据
				this.setData({
					project,
					currentProject: project
				});
				
				// 更新缓存
				await this._cacheProjectData(this.data.id, project);
				
				// 刷新页面数据
				await this._loadProjectData(this.data.id);
				
				// 提示状态更新成功
				wx.showToast({
					title: '状态更新成功',
					icon: 'success'
				});
			}
		} catch (err) {
			console.error('[项目详情] 状态更新失败:', err);
			wx.showToast({
				title: '状态更新失败: ' + (err.message || '未知错误'),
				icon: 'none'
			});
		} finally {
			wx.hideLoading();
		}
	},
	
	/**
	 * 处理状态图谱创建事件
	 * @param {Object} e 组件事件对象
	 */
	onStateGraphCreated(e) {
		console.log('状态图谱已创建', e.detail);
		const { graphData } = e.detail;
		if (graphData) {
			// 在这里可以进行图谱数据的处理和可视化
			// 例如：传递给图谱组件或跳转到图谱页面
			this.setData({
				stateGraphData: graphData
			});
			
			// 如果需要跳转到图谱页面
			// wx.navigateTo({
			//   url: `/projects/plm/pages/project/graph/state_graph?id=${this.data.id}`
			// });
		}
	},

	/**
	 * 项目初始化时设置用户角色
	 */
	_initProjectPermissions() {
		// 从用户信息中获取角色
		const userInfo = app?.globalData?.userInfo || this.data.user || {};
		
		// 确定用户角色
		let userRole = 'visitor'; // 默认访客
		
		// 判断是否是管理员
		const isAdmin = this.data.isAdmin || (userInfo && userInfo.ROLE === 'ADMIN');
		if (isAdmin) {
			userRole = 'admin';
		} else if (this.data.project) {
			// 判断是否是项目负责人
			if (userInfo.USER_ID === this.data.project.RESEARCH_PROJECT_CAPT) {
				userRole = 'owner';
			} 
			// 判断是否是项目成员
			else if (this.data.project.RESEARCH_PROJECT_MEMBERS && 
					 this.data.project.RESEARCH_PROJECT_MEMBERS.includes(userInfo.USER_ID)) {
				userRole = 'member';
			}
		}
		
		// 更新页面数据
		this.setData({
			userRole,
			isAdmin: userRole === 'admin',
			isOwner: userRole === 'owner',
			hasFlowPermission: userRole === 'admin' || userRole === 'owner'
		});
		
		return userRole;
	},

	/**
	 * 处理分支树节点点击事件
	 * @param {Object} e 组件事件对象
	 */
	onBranchNodeTap(e) {
		const { nodeId, node } = e.detail;
		console.log('分支节点点击:', node);
		
		// 如果点击的是当前分支，不做处理
		if (this.data.currentBranch && this.data.currentBranch._id === nodeId) {
			wx.showToast({
				title: '当前已在该分支',
				icon: 'none'
			});
			return;
		}
		
		// 提示用户是否切换分支
		wx.showModal({
			title: '切换分支',
			content: `确定切换到分支"${node.name}"吗？`,
			success: (res) => {
				if (res.confirm) {
					this.switchBranch(nodeId);
				}
			}
		});
	},

	/**
	 * 切换到指定分支
	 * @param {String} branchId 分支ID
	 */
	async switchBranch(branchId) {
		try {
			this.setData({ loading: true });
			
			// 设置超时保护
			const loadingTimeout = setTimeout(() => {
				console.warn('[项目详情] 分支加载超时，重置加载状态');
				this.setData({ loading: false });
				wx.showToast({
					title: '分支加载超时',
					icon: 'none'
				});
			}, 15000); // 15秒超时保护
			
			// 检查branchId是否为空
			if (!branchId) {
				console.log('[项目详情] 没有提供分支ID，加载项目基本信息');
				wx.showToast({
					title: '加载项目信息...',
					icon: 'none'
				});
				clearTimeout(loadingTimeout);
				this.setData({ loading: false });
				return;
			}
			
			// 尝试加载分支详细数据
			let branchData = null;
			try {
				// 加载分支详细数据
				branchData = await branchService.getBranchDetail(branchId);
			} catch (error) {
				console.error('[项目详情] 加载分支数据失败:', error);
				// 分支加载失败不阻断流程
				wx.showToast({
					title: '分支数据加载失败，使用基本信息',
					icon: 'none'
				});
			}
			
			// 如果没有获取到分支数据，使用空对象，仍然加载项目数据
			if (!branchData) {
				branchData = {
					_id: branchId,
					name: '未知分支'
				};
			}
			
			// 将分支数据与项目数据合并
			let projectWithBranch = this.data.project;
			try {
				projectWithBranch = branchService.getBranchDataMapping(
					this.data.project,
					branchData
				);
			} catch (mappingError) {
				console.error('[项目详情] 分支数据映射失败:', mappingError);
				// 使用原项目数据
			}
			
			// 更新当前分支状态
			this.setData({
				currentBranch: branchData,
				currentBranchIndex: this.data.branchOptions.findIndex(b => b.id === branchId),
				project: projectWithBranch,
				branchId,
				loading: false
			});
			
			// 清除超时保护
			clearTimeout(loadingTimeout);
			
			// 重新加载相关标签页内容
			try {
				await this.loadActiveTabContent();
			} catch (error) {
				console.error('[项目详情] 加载标签内容失败:', error);
				// 忽略标签加载错误
			}
		} catch (error) {
			console.error('[项目详情] 分支切换失败:', error);
			this.setData({ loading: false });
			
			wx.showToast({
				title: '分支切换失败',
				icon: 'none'
			});
		}
	},

	/**
	 * 初始化项目分支
	 */
	async _initBranches() {
		try {
			console.log('[项目详情] 初始化分支数据');
			// 加载项目的分支列表
			const options = {
				title: '加载分支...',
				hasLoading: false
			};
			
			const result = await cloudHelper.callCloudData('plm/branch_list', {
				projectId: this.data.id
			}, options);
			
			if (!result || !result.list) {
				console.warn('[项目详情] 获取分支列表失败');
				return;
			}
			
			// 预处理分支数据
			const branchList = result.list.map(item => ({
				...item,
				id: item._id,
				name: item.name || item.BRANCH_NAME || '未命名分支',
				isMaster: item.isMaster || item.IS_MASTER || false
			}));
			
			// 构建分支选项
			const branchOptions = branchList.map(branch => ({
				id: branch.id,
				name: branch.name,
				isMaster: branch.isMaster
			}));
			
			// 如果没有主分支，添加一个默认主分支选项
			if (!branchOptions.some(b => b.isMaster)) {
				branchOptions.unshift({
					id: '',
					name: '主分支',
					isMaster: true
				});
			}
			
			// 获取当前项目使用的分支ID
			const currentBranchId = this.data.project.branchId || '';
			
			// 查找当前选中的分支索引
			const currentBranchIndex = branchOptions.findIndex(item => 
				item.id === currentBranchId
			);
			
			// 如果找不到当前分支，默认选择主分支
			const defaultIndex = currentBranchIndex >= 0 ? currentBranchIndex : 
				branchOptions.findIndex(item => item.isMaster);
			
			this.setData({
				branchList,
				branchOptions,
				currentBranchId: currentBranchId || (branchOptions[defaultIndex]?.id || ''),
				currentBranchIndex: defaultIndex >= 0 ? defaultIndex : 0
			});
			
			console.log('[项目详情] 分支初始化完成', this.data.branchOptions);
			
			// 如果当前项目没有分支ID但有分支选项，自动设置第一个分支
			if (!this.data.project.branchId && this.data.branchOptions.length > 0) {
				const firstBranch = branchOptions[defaultIndex >= 0 ? defaultIndex : 0];
				console.log('[项目详情] 自动设置分支', firstBranch);
				if (firstBranch && firstBranch.id) {
					await this.switchBranch(firstBranch.id);
				}
			}
		} catch (error) {
			console.error('[项目详情] 初始化分支失败', error);
		}
	},

	/**
	 * 更新项目计算属性数据
	 * 在项目数据加载后调用，处理状态、日期等计算属性
	 */
	_updateComputedData() {
		const project = this.data.project || this.data.currentProject;
		if (!project) return;
		
		// 克隆项目以避免直接修改原始数据
		const formattedProject = { ...project };
		
		// 设置项目状态文本
		this._setProjectStatusText(formattedProject);
		
		// 计算项目进度
		this._calculateProgress(formattedProject);
		
		// 格式化日期字段
		if (formattedProject.startDate) {
			formattedProject.startDateFormatted = dateHelper.timestampToDate(formattedProject.startDate, 'YYYY-MM-DD');
		}
		
		if (formattedProject.endDate) {
			formattedProject.endDateFormatted = dateHelper.timestampToDate(formattedProject.endDate, 'YYYY-MM-DD');
			
			// 计算截止日期状态
			formattedProject.deadlineStatus = dateHelper.getDeadlineStatus(formattedProject.endDate);
			formattedProject.deadlineText = dateHelper.getDeadlineText(formattedProject.endDate);
		}
		
		if (formattedProject.createTime) {
			formattedProject.createTimeFormatted = dateHelper.timestampToDate(formattedProject.createTime, 'YYYY-MM-DD HH:mm');
		}
		
		if (formattedProject.updateTime) {
			formattedProject.updateTimeFormatted = dateHelper.timestampToDate(formattedProject.updateTime, 'YYYY-MM-DD HH:mm');
		}
		
		// 确保developmentStatus字段存在
		if (!formattedProject.developmentStatus) {
			if (statusHelper && typeof statusHelper.getDevelopmentStatus === 'function') {
				formattedProject.developmentStatus = statusHelper.getDevelopmentStatus(formattedProject);
			} else {
				// 备选计算逻辑
				const level1 = formattedProject.level1;
				if (level1 === 1) formattedProject.developmentStatus = '待立项';
				else if (level1 === 2) formattedProject.developmentStatus = '休眠状态';
				else if (level1 === 3) {
					// 使用level2进一步细分
					const level2 = formattedProject.level2;
					if (level2 === 'planning') formattedProject.developmentStatus = '规划中';
					else if (level2 === 'design') formattedProject.developmentStatus = '设计中';
					else if (level2 === 'development') formattedProject.developmentStatus = '开发中';
					else if (level2 === 'testing') formattedProject.developmentStatus = '测试中';
					else if (level2 === 'validation') formattedProject.developmentStatus = '验证中';
					else formattedProject.developmentStatus = '开发中';
				}
				else if (level1 === 4) formattedProject.developmentStatus = '暂停状态';
				else if (level1 === 5) formattedProject.developmentStatus = '延期状态';
				else if (level1 === 6) formattedProject.developmentStatus = '搁置状态';
				else if (level1 === 99) formattedProject.developmentStatus = '已完成';
				else formattedProject.developmentStatus = '开发中';
			}
		}
		
	// 确保完整状态描述字段存在
	if (!formattedProject.fullStatusDesc && statusHelper && typeof statusHelper.getFullStatusDesc === 'function') {
		formattedProject.fullStatusDesc = statusHelper.getFullStatusDesc(formattedProject);
	}
	
	// 设置项目开发状态颜色
	formattedProject.statusColor = statusHelper.getStatusColor(formattedProject.status);
	formattedProject.statusBgColor = statusHelper.getStatusBgColor(formattedProject.status);
	
	// 设置项目进度颜色
	const progress = this.data.progress || statusHelper.getCompletionPercentage(formattedProject);
	formattedProject.progressColor = statusHelper.getProgressColor(progress);
	
	// 更新项目数据
	this.setData({
		project: formattedProject,
		currentProject: formattedProject
	});
	},
	
	/**
	 * 跳转到分支管理页面
	 */
	onManageBranchesTap() {
		const { id, project } = this.data;
		
		wx.navigateTo({
			url: `/projects/plm/pages/project/branch/branch_manager?id=${id}&name=${encodeURIComponent(project.PROJECT_NAME || project.model || '项目')}`
		});
	},

	/**
	 * 处理分支切换
	 * @param {Object} e 事件对象
	 */
	async handleBranchChange(e) {
		const index = e.detail.value;
		if (index == null || index === this.data.currentBranchIndex) return;
		
		const branchId = this.data.branchOptions[index]._id;
		await this.switchBranch(branchId);
	},

	/**
	 * 加载分支列表
	 */
	async loadBranches() {
		// 设置超时保护
		const loadingTimeout = setTimeout(() => {
			console.warn('[项目详情] 加载分支超时，使用默认设置');
			this.setData({
				branchOptions: [{
					_id: '',
					name: '主分支 (默认)',
					isMain: true
				}],
				currentBranchIndex: 0,
				currentBranch: {
					_id: '',
					name: '主分支 (默认)',
					isMain: true
				}
			});
		}, 10000); // 10秒超时保护
		
		try {
			if (!this.data.id) {
				console.error('[项目详情] 缺少项目ID');
				clearTimeout(loadingTimeout);
				return;
			}
			
			// 显示加载中
			wx.showLoading({
				title: '加载分支...',
				mask: false
			});
			
			console.log('[项目详情] 开始加载分支数据');
			
			// 获取项目所有分支
			let branches = [];
			try {
				// 直接调用云函数获取分支列表
				const result = await cloudHelper.callCloudData('plm/branch_list', {
					projectId: this.data.id
				}, { hasLoading: false });
				
				if (result && result.list && Array.isArray(result.list)) {
					branches = result.list.map(branch => ({
						_id: branch._id || branch.id,
						id: branch._id || branch.id,
						name: branch.name || branch.BRANCH_NAME || '未命名分支',
						isMain: branch.isMaster || branch.IS_MAIN || false
					}));
				}
			} catch (apiError) {
				console.error('[项目详情] 通过API获取分支列表失败:', apiError);
				// 失败后尝试通过服务获取
				try {
					branches = await branchService.getBranchList(this.data.id);
				} catch (serviceError) {
					console.error('[项目详情] 通过服务获取分支列表失败:', serviceError);
					// 两种方式都失败，设置默认分支
					branches = [];
				}
			}
			
			// 如果没有分支，设置默认分支
			if (!branches || branches.length === 0) {
				console.log('[项目详情] 项目没有分支，设置默认主分支');
				this.setData({
					branchOptions: [{
						_id: '',
						id: '',
						name: '主分支',
						isMain: true
					}],
					currentBranchIndex: 0,
					currentBranch: {
						_id: '',
						id: '',
						name: '主分支',
						isMain: true
					},
					hasNoValidBranch: true  // 标记没有有效分支
				});
				
				clearTimeout(loadingTimeout);
				wx.hideLoading();
				return;
			}
			
			console.log('[项目详情] 成功获取分支列表:', branches);
			
			// 更新界面
			this.setData({
				branchOptions: branches,
				// 默认选择主分支
				currentBranchIndex: Math.max(0, branches.findIndex(b => b.isMain)),
				currentBranch: branches.find(b => b.isMain) || branches[0],
				hasNoValidBranch: false
			});
			
			// 如果有指定分支ID，切换到指定分支
			if (this.data.branchId) {
				const targetBranchIndex = branches.findIndex(b => b._id === this.data.branchId || b.id === this.data.branchId);
				if (targetBranchIndex >= 0) {
					this.setData({ currentBranchIndex: targetBranchIndex });
					await this.switchBranch(this.data.branchId);
				} else {
					// 指定的分支不存在，使用主分支
					const mainBranch = branches.find(b => b.isMain) || branches[0];
					await this.switchBranch(mainBranch._id || mainBranch.id);
				}
			} else {
				// 没有指定分支ID时，加载主分支
				const mainBranch = branches.find(b => b.isMain) || branches[0];
				if (mainBranch) {
					await this.switchBranch(mainBranch._id || mainBranch.id);
				}
			}
			
			clearTimeout(loadingTimeout);
			wx.hideLoading();
			
		} catch (error) {
			console.error('[项目详情] 加载分支失败:', error);
			
			clearTimeout(loadingTimeout);
			wx.hideLoading();
			
			// 出错时设置默认状态，避免影响其他功能
			this.setData({
				branchOptions: [{
					_id: '',
					id: '',
					name: '主分支 (默认)',
					isMain: true
				}],
				currentBranchIndex: 0,
				currentBranch: {
					_id: '',
					id: '',
					name: '主分支 (默认)',
					isMain: true
				},
				hasNoValidBranch: true
			});
			
			// 显示错误提示
			wx.showToast({
				title: '分支加载失败，使用默认设置',
				icon: 'none'
			});
		}
	},

	/**
	 * 加载状态历史
	 */
	async loadStateHistory() {
		try {
			if (!this.data.id || !this.data.branchId) return;
			
			const history = await stateService.getStateHistory(
				this.data.id, 
				this.data.branchId
			);
			
			this.setData({ stateHistory: history });
		} catch (error) {
			console.error('加载状态历史失败:', error);
		}
	},

	/**
	 * 加载可用状态流转操作
	 */
	async loadAvailableTransitions() {
		try {
			if (!this.data.id || !this.data.branchId) return;
			
			const transitions = await stateService.getAvailableTransitions(
				this.data.id, 
				this.data.branchId
			);
			
			this.setData({ availableTransitions: transitions });
		} catch (error) {
			console.error('加载可用状态流转失败:', error);
		}
	},

	/**
	 * 处理状态流转操作
	 * @param {Object} e 事件对象
	 */
	async handleStateTransition(e) {
		try {
			// 从按钮数据中获取转换信息
			const { transitionId } = e.currentTarget.dataset;
			const transition = this.data.availableTransitions.find(t => t.id === transitionId);
			
			if (!transition) {
				wx.showToast({
					title: '找不到此转换操作',
					icon: 'none'
				});
				return;
			}
			
			// 准备转换数据
			const transitionData = {
				projectId: this.data.id,
				branchId: this.data.branchId,
				fromState: {
					level1: this.data.currentProject.level1,
					level2: this.data.currentProject.level2,
					level3: this.data.currentProject.level3,
					level4: this.data.currentProject.level4
				},
				toState: transition.targetState,
				eventType: transition.eventType || 'user',
				comment: transition.comment || ''
			};
			
			// 检查前置条件
			const preconditionCheck = await stateService.checkTransitionPreconditions(transitionData);
			if (!preconditionCheck.success) {
				wx.showModal({
					title: '无法执行状态流转',
					content: preconditionCheck.message,
					showCancel: false
				});
				return;
			}
			
			// 执行状态流转
			const result = await stateService.transitionState(transitionData);
			
			if (result.code === 0) {
				wx.showToast({
					title: '状态流转成功',
					icon: 'success'
				});
				
				// 重新加载项目详情和分支信息
				await this.loadProjectDetail();
			} else {
				wx.showModal({
					title: '状态流转失败',
					content: result.message || '未知错误',
					showCancel: false
				});
			}
		} catch (error) {
			console.error('状态流转失败:', error);
			wx.showToast({
				title: '状态流转失败: ' + error.message,
				icon: 'none'
			});
		}
	},

	/**
	 * 加载当前标签页内容
	 */
	async loadActiveTabContent() {
		const activeTab = this.data.tabCur;
		
		switch (activeTab) {
			case 0: // 图谱
				await this.loadBranchGraph();
				break;
			case 1: // 总览
				// 总览标签不需要额外加载
				break;
			case 2: // 流转
				await this.loadWorkflowTab();
				break;
			case 3: // 任务
				await this.loadTasksTab();
				break;
			case 4: // 资料
				await this.loadDocumentsTab();
				break;
			case 5: // 反馈
				await this.loadFeedbackTab();
				break;
		}
	},

	/**
	 * 加载分支图谱
	 */
	async loadBranchGraph() {
		try {
			// 获取项目所有分支
			const branches = await branchService.getBranchList(this.data.id);
			
			if (!branches || branches.length === 0) {
				this.setData({
					branchGraph: {
						nodes: [],
						links: []
					}
				});
				return;
			}
			
			// 构建分支图谱
			const branchGraph = branchService.buildBranchTree(branches);
			this.setData({ branchGraph });
		} catch (error) {
			console.error('加载分支图谱失败:', error);
		}
	},

	/**
	 * 加载流转标签页
	 */
	async loadWorkflowTab() {
		try {
			// 加载状态历史和可用流转操作
			await Promise.all([
				this.loadStateHistory(),
				this.loadAvailableTransitions()
			]);
		} catch (error) {
			console.error('加载工作流标签页失败:', error);
		}
	},

	/**
	 * 加载任务标签页
	 */
	async loadTasksTab() {
		// 加载当前分支的任务列表
		// 实现省略
	},

	/**
	 * 加载资料标签页
	 */
	async loadDocumentsTab() {
		// 加载当前分支的资料列表
		// 实现省略
	},

	/**
	 * 加载反馈标签页
	 */
	async loadFeedbackTab() {
		// 加载当前分支的反馈列表
		// 实现省略
	},

	// 修改onLoad方法，添加分支数据加载
	async onLoad(options) {
		// 现有代码...
		
		// 获取项目ID和可能的分支ID
		const id = options.id;
		const branchId = options.branchId || null;
		
		if (!id) {
			wx.showToast({
				title: '缺少项目ID',
				icon: 'none'
			});
			
			setTimeout(() => {
				wx.navigateBack();
			}, 1000);
			
			return;
		}
		
		this.setData({
			id,
			branchId
		});
		
		this._loadDetail();
	},
	
	// 修改_loadDetail方法，添加分支加载
	async _loadDetail() {
		try {
			wx.showLoading({ title: '加载中...' });
			
			// 加载基本项目信息
			const projectId = this.data.id;
			if (!projectId) {
				wx.showToast({
					title: '项目ID无效',
					icon: 'error'
				});
				
				// 重置加载状态
				this.setData({ loading: false });
				return;
			}
			
			// 先加载项目基本数据
			const project = await this._loadProjectData(projectId);
			if (!project) {
				// _loadProjectData方法内部已经处理了错误提示和状态
				return;
			}
			
			// 设置项目数据
			this.setData({
				project,
				currentProject: { ...project },
				loading: false
			});
			
			// 更新计算属性数据
			this._updateComputedData();
			
			// 尝试加载分支信息（分支加载错误不应阻止整个页面加载）
			try {
				await this.loadBranches();
			} catch (branchError) {
				console.error('[项目详情] 分支加载异常:', branchError);
				// 尝试重试一次
				try {
					console.log('[项目详情] 尝试重新加载分支信息');
					setTimeout(async () => {
						await this.loadBranches().catch(e => {
							console.warn('[项目详情] 重试加载分支也失败:', e);
						});
					}, 1000);
				} catch (retryError) {
					console.warn('[项目详情] 重试加载分支安排失败:', retryError);
				}
				
				// 设置默认状态，避免影响其他功能
				this.setData({
					branchOptions: [{
						_id: '',
						name: '主分支 (默认)',
						isMain: true
					}],
					currentBranchIndex: 0,
					currentBranch: {
						_id: '',
						name: '主分支 (默认)',
						isMain: true
					},
					hasNoValidBranch: true
				});
			} finally {
				// 无论分支是否加载成功，都尝试加载当前标签页内容
				try {
					await this.loadActiveTabContent();
				} catch (tabError) {
					console.error('[项目详情] 标签内容加载失败:', tabError);
				}
			}
			
			// 加载完成
			wx.hideLoading();
		} catch (error) {
			console.error('[项目详情] 加载项目详情失败:', error);
			wx.hideLoading();
			
			// 确保更新加载状态，避免一直显示加载中
			this.setData({
				loading: false,
				error: true,
				errorMessage: error.message || '加载失败'
			});
			
			wx.showToast({
				title: '加载失败',
				icon: 'error'
			});
		}
	}
}); 